Celestin Apprentice 4/Apprentice-Release4.iso/Source Code/PowerPlant/3D Additions 1.7/3D Additions/3DUtilities.cp

Text File | 1995-10-09 | 16.0 KB | 595 lines | [TEXT/CWIE]

// ===========================================================================
// 3DUtilities.cp      ©1995 J. Rodden, DD/MF & Associates. All rights reserved
// ===========================================================================
// Utilities for drawing 3D effects.
//
// This is intended to look and act as much like a Toolbox Manager as possible.
// You should use the first set of procedures in general, but the second set
// is directly available for flexibility.
//
// This source code is loosely based on and heavily inspired by source code
// by James W. Osborne, copyright (c) 1993, Apple Computer.

#include "3DUtilities.h"

// ===========================================================================
// Local variables. Statics are used rather than a class to allow ANSI C usage.
// ===========================================================================

static RGBColor theLightColor    = kWhite;
static RGBColor theShadowColor    = kShadowGray;
static RGBColor theBkgndColor    = kBackgroundGray;
static PenState    thePnState        = {{0,0},{1,1},srcCopy,
                                    {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF}};

// ===========================================================================
// Static function prototypes.
// ===========================================================================

static PenState    theOldPnState;    // only used by static functions.

static void    GetCPen();
static void    GetBWPen();
static void    SavePenState();
static void    RestorePenState();


// ===========================================================================
// Accessor functions to 3D colors.
// ===========================================================================

// • Get 3D State
void Get3DBackColor( RGBColor *outBkgndColor)    { *outBkgndColor = theBkgndColor; }

void Get3DLightColor( RGBColor *outLightColor)    { *outLightColor = theLightColor; }

void Get3DShadowColor( RGBColor *outShadowColor){ *outShadowColor= theShadowColor; }

void Get3DPenState( PenState *outPnState)        { *outPnState     = thePnState; }


// • Set 3D State
void Set3DBackColor(const RGBColor *inBkgndColor)    { theBkgndColor     = *inBkgndColor; }

void Set3DLightColor(const RGBColor *inLightColor)    { theLightColor     = *inLightColor; }

void Set3DShadowColor(const RGBColor *inShadowColor){ theShadowColor = *inShadowColor; }

void Set3DPenState(const PenState *inPnState)        { thePnState     = *inPnState; }


// ===========================================================================
// ===========================================================================

// ---------------------------------------------------------------------------
//        • Draw3DOvalPanel
// ---------------------------------------------------------------------------
// Draw a 3D oval panel (raised or embedded) in the current grafPort
// using the current PenState.

void    Draw3DOvalPanel(
    const Rect*        inRect,
    const RGBColor*    inBKColor,
    const RGBColor*    inULColor,
    const RGBColor*    inLRColor,
    const Boolean    inFrameIt)
{
    RGBColor    theForeColor;

    GetForeColor( &theForeColor);

    // Paint background color
    RGBForeColor(inBKColor);
    PaintOval(inRect);

    // Draw oval border
    Draw3DOvalBorder( inRect, inULColor, inLRColor, inFrameIt);

    RGBForeColor( &theForeColor);
}

// ===========================================================================

// • Draw3DInsetOvalPanel
void Draw3DInsetOvalPanel(const Rect *inRect)
{
    SavePenState();
    GetCPen();
    Draw3DOvalPanel(inRect, &theLightColor, &theShadowColor, &theLightColor, true);
    RestorePenState();
}

// • Draw3DRaisedOvalPanel
void Draw3DRaisedOvalPanel(const Rect *inRect)
{
    SavePenState();
    GetCPen();
    Draw3DOvalPanel(inRect, &theBkgndColor, &theLightColor, &theShadowColor, false);
    RestorePenState();
}


// ===========================================================================
// ===========================================================================

// ---------------------------------------------------------------------------
//        • Draw3DOvalBorder
// ---------------------------------------------------------------------------
// Draw a 3D oval border (raised or embedded) in the current grafPort
// using the current PenState.

void    Draw3DOvalBorder(
    const Rect*        inRect,
    const RGBColor*    inULColor,
    const RGBColor*    inLRColor,
    const Boolean    inFrameIt)
{
    RGBColor    theForeColor;

    GetForeColor( &theForeColor);

    // Draw upper left color
    RGBForeColor(inULColor);
    FrameOval(inRect);

    // Draw lower right color
    RGBForeColor(inLRColor);
    FrameArc( inRect, 45, 180);

    // Draw inner oval (frame)
    if (inFrameIt) {
        Rect tempRect = *inRect;
        InsetRect(&tempRect,thePnState.pnSize.h,thePnState.pnSize.v);
        RGBForeColor(&kBlack); FrameOval(&tempRect);
    }

    RGBForeColor( &theForeColor);
}

// ===========================================================================

// • Draw3DInsetOvalBorder
void Draw3DInsetOvalBorder(const Rect *inRect)
{
    SavePenState();
    GetCPen();
    Draw3DOvalBorder(inRect, &theShadowColor, &theLightColor, false);
    RestorePenState();
}

// • Draw3DRaisedOvalBorder
void Draw3DRaisedOvalBorder(const Rect *inRect)
{
    SavePenState();
    GetCPen();
    Draw3DOvalBorder(inRect, &theLightColor, &theShadowColor, false);
    RestorePenState();
}


// ===========================================================================
// ===========================================================================

// ---------------------------------------------------------------------------
//        • Draw3DOvalFrame
// ---------------------------------------------------------------------------
// Draw a 3D oval frame (raised or embedded) in the current grafPort
// using the current PenState.

void    Draw3DOvalFrame(
    const Rect*        inRect,
    const RGBColor*    inULColor,
    const RGBColor*    inLRColor)
{
    Rect tempRect = *inRect;
    RGBColor theForeColor;

    GetForeColor( &theForeColor);

    RGBForeColor(inULColor);
    FrameOval(&tempRect);

    OffsetRect(&tempRect,thePnState.pnSize.h, thePnState.pnSize.v);

    RGBForeColor(inLRColor);
    FrameOval(&tempRect);

    RGBForeColor( &theForeColor);
}

// ===========================================================================

// • Draw3DInsetOvalFrame
void Draw3DInsetOvalFrame(const Rect *inRect)
{
    SavePenState();
    GetCPen();
    Draw3DOvalFrame(inRect, &theShadowColor, &theLightColor);
    RestorePenState();
}

// • Draw3DRaisedOvalFrame
void Draw3DRaisedOvalFrame(const Rect *inRect)
{
    SavePenState();
    GetCPen();
    Draw3DOvalFrame(inRect, &theLightColor, &theShadowColor);
    RestorePenState();
}


// ===========================================================================
// ===========================================================================

// ---------------------------------------------------------------------------
//        • Draw3DPanel
// ---------------------------------------------------------------------------
// Draw a 3D panel (raised or embedded) in the current grafPort
// using the current PenState.

void    Draw3DPanel(
    const Rect*        inRect,
    const RGBColor*    inBKColor,
    const RGBColor*    inULColor,
    const RGBColor*    inLRColor,
    const Boolean    inFrameIt)
{
    RGBColor    theForeColor;

    GetForeColor( &theForeColor);

    // Paint background color
    RGBForeColor(inBKColor);
    PaintRect(inRect);

    Draw3DBorder( inRect, inULColor, inLRColor, inFrameIt);

    RGBForeColor( &theForeColor);
}

// ===========================================================================

// • Draw3DInsetPanel
void Draw3DInsetPanel(const Rect *inRect)
{
    SavePenState();
    GetCPen();
    Draw3DPanel(inRect, &theLightColor, &theShadowColor, &theLightColor, true);
    RestorePenState();
}

// • Draw3DRaisedPanel
void Draw3DRaisedPanel(const Rect *inRect)
{
    SavePenState();
    GetCPen();
    Draw3DPanel(inRect, &theBkgndColor, &theLightColor, &theShadowColor, false);
    RestorePenState();
}


// ===========================================================================
// ===========================================================================

// ---------------------------------------------------------------------------
//        • Draw3DBorder
// ---------------------------------------------------------------------------
// Draw a 3D panel border (raised or embedded) in the current grafPort
// using the current PenState.

void    Draw3DBorder(
    const Rect*        inRect,
    const RGBColor*    inULColor,
    const RGBColor*    inLRColor,
    const Boolean    inFrameIt)
{
    PenState    thePnState;
    RGBColor    theForeColor;

    GetPenState( &thePnState);
    GetForeColor( &theForeColor);

    // Draw lower right (shadow) lines
    RGBForeColor(inLRColor);
    FrameRect(inRect);

    // Draw upper left (light source) lines
    RGBForeColor(inULColor);
    MoveTo( inRect->left, inRect->bottom - thePnState.pnSize.v);
    LineTo( inRect->left, inRect->top);
    LineTo( inRect->right - thePnState.pnSize.h, inRect->top);

    // Draw inner box (frame)
    if (inFrameIt) {
        Rect tempRect = *inRect;
        InsetRect(&tempRect,thePnState.pnSize.h,thePnState.pnSize.v);
        RGBForeColor(&kBlack);
        FrameRect(&tempRect);
    }

    RGBForeColor(&theForeColor);
}

// ===========================================================================

// • Draw3DInsetBorder
void    Draw3DInsetBorder(const Rect *inRect)
{
    SavePenState();
    GetCPen();
    Draw3DBorder(inRect, &theShadowColor, &theLightColor, false);
    RestorePenState();
}

// • Draw3DRaisedBorder
void    Draw3DRaisedBorder(const Rect *inRect)
{
    SavePenState();
    GetCPen();
    Draw3DBorder(inRect, &theLightColor, &theShadowColor, false);
    RestorePenState();
}


// ===========================================================================
// ===========================================================================

// ---------------------------------------------------------------------------
//        • Draw3DFrame
// ---------------------------------------------------------------------------
// Draw a 3D rect (raised or embedded) in the current grafPort using the
// current PenState.

void
Draw3DFrame(
    const Rect*        inRect,
    const RGBColor*    inULColor,
    const RGBColor*    inLRColor)
{
    Rect        tempRect = *inRect;
    PenState    thePnState;
    RGBColor    theForeColor;

    GetPenState(&thePnState);
    GetForeColor(&theForeColor);

    tempRect.right -= thePnState.pnSize.h;
    tempRect.bottom -= thePnState.pnSize.v;

    RGBForeColor(inULColor);
    FrameRect(&tempRect);

    OffsetRect(&tempRect,thePnState.pnSize.h, thePnState.pnSize.v);

    RGBForeColor(inLRColor);
    FrameRect(&tempRect);

    RGBForeColor(&theForeColor);
}

// ===========================================================================

// • Draw3DInsetFrame
void Draw3DInsetFrame(const Rect *inRect)
{
    SavePenState();
    GetCPen();
    Draw3DFrame(inRect, &theShadowColor, &theLightColor);
    RestorePenState();
}

// • Draw3DRaisedFrame
void Draw3DRaisedFrame(const Rect *inRect)
{
    SavePenState();
    GetCPen();
    Draw3DFrame(inRect, &theLightColor, &theShadowColor);
    RestorePenState();
}


// ===========================================================================
// ===========================================================================

// ---------------------------------------------------------------------------
//        • Draw3DHLine
// ---------------------------------------------------------------------------
// Draw a 3D line (raised or embedded) horizontally accross the current grafPort
// using the current PenState.

void
Draw3DHLine(const short vpos, const short h1, const short h2,
            const RGBColor *inULColor, const RGBColor *inLRColor)
{
    PenState    thePnState;
    RGBColor    theForeColor;

    GetPenState( &thePnState);
    GetForeColor( &theForeColor);

    DrawCLine( inULColor, h1, vpos, h2, vpos);
    DrawCLine( inLRColor, h1, vpos+thePnState.pnSize.v,
                          h2, vpos+thePnState.pnSize.v);

    RGBForeColor( &theForeColor);
}

// ===========================================================================

// • Draw3DInsetHLine
void Draw3DInsetHLine(const short vpos, const short h1, const short h2)
{
    SavePenState();
    GetCPen();
    Draw3DHLine( vpos, h1, h2, &theShadowColor, &theLightColor);
    RestorePenState();
}

// • Draw3DRaisedHLine
void Draw3DRaisedHLine(const short vpos, const short h1, const short h2)
{
    SavePenState();
    GetCPen();
    Draw3DHLine( vpos, h1, h2, &theLightColor, &theShadowColor);
    RestorePenState();
}


// ===========================================================================
// ===========================================================================

// ---------------------------------------------------------------------------
//        • Draw3DVLine
// ---------------------------------------------------------------------------
// Draw a 3D line (raised or embedded) vertically accross the current grafPort
// using the current PenState.

void
Draw3DVLine(const short hpos, const short v1, const short v2,
            const RGBColor *inULColor, const RGBColor *inLRColor)
{
    PenState    thePnState;
    RGBColor    theForeColor;

    GetPenState( &thePnState);
    GetForeColor( &theForeColor);

    DrawCLine( inULColor, hpos, v1, hpos, v2);
    DrawCLine( inLRColor, hpos+thePnState.pnSize.h, v1,
                          hpos+thePnState.pnSize.h, v2);

    RGBForeColor( &theForeColor);
}

// ===========================================================================

// • Draw3DInsetVLine
void Draw3DInsetVLine(const short hpos, const short v1, const short v2)
{
    SavePenState();
    GetCPen();
    Draw3DVLine( hpos, v1, v2, &theShadowColor, &theLightColor);
    RestorePenState();
}

// • Draw3DRaisedVLine
void Draw3DRaisedVLine(const short hpos, const short v1, const short v2)
{
    SavePenState();
    SavePenState();
    GetCPen();
    Draw3DVLine( hpos, v1, v2, &theLightColor, &theShadowColor);
    RestorePenState();
}


// ===========================================================================
// ===========================================================================

// ---------------------------------------------------------------------------
//        • DrawCLine
// ---------------------------------------------------------------------------
// Draw a colored line within the current grafPort using the current PenState.

void
DrawCLine(const RGBColor *theColor,
          const short h1, const short v1, const short h2, const short v2)
{
    MoveTo( h1, v1);
    CLineTo( theColor, h2, v2);
}

// ---------------------------------------------------------------------------
//        • CLineTo
// ---------------------------------------------------------------------------
// Draw a colored line within the current grafPort using the current PenState.

void
CLineTo(const RGBColor *theColor, const short h, const short v)
{
    RGBForeColor(theColor);
    LineTo( h, v);
}


// ===========================================================================
// ===========================================================================

// ---------------------------------------------------------------------------
//        • BWShadowInset
// ---------------------------------------------------------------------------

void
BWShadowInset(const Rect* inRect)
{
    if ( inRect != nil ) {
        SavePenState();
        GetBWPen();

        MoveTo( inRect->left, inRect->bottom);
        LineTo( inRect->left, inRect->top);
        LineTo( inRect->right, inRect->top);

        RestorePenState();
    }
}


// ---------------------------------------------------------------------------
//        • BWShadowRaised
// ---------------------------------------------------------------------------

void
BWShadowRaised(const Rect* inRect)
{
    if ( inRect != nil ) {
        SavePenState();
        GetBWPen();

        MoveTo( inRect->left, inRect->bottom);
        LineTo( inRect->right, inRect->bottom);
        LineTo( inRect->right, inRect->top);

        RestorePenState();
    }
}


// ---------------------------------------------------------------------------
//        • BWShadowLine
// ---------------------------------------------------------------------------
// Draw a BW shadowed line within the current grafPort using the current PenState.

void
BWShadowLine(const short h1, const short v1, const short h2, const short v2)
{
    SavePenState();
    GetBWPen();

    MoveTo( h1, v1);
    LineTo( h2, v2);

    RestorePenState();
}


// ===========================================================================
// ===========================================================================

void GetCPen()
{    SetPenState( &thePnState); }

void GetBWPen()
{
    Pattern grey = {0xFFFFFFE8};
    GetCPen();
    PenPat(&grey);
}

void SavePenState()
{    GetPenState( &theOldPnState); }

void RestorePenState()
{    SetPenState( &theOldPnState); }